package com.aizuda.boot.modules.business.template.service;

import com.aizuda.boot.modules.business.template.utils.FieldCodeGenerator;
import com.aizuda.boot.modules.business.template.entity.ContractTemplateFieldEntity;
import com.aizuda.boot.modules.business.template.mapper.ContractTemplateFieldMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import jakarta.annotation.Resource;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 合同模板字段编码管理服务
 * 提供字段编码生成、验证等功能
 * 
 * @author system
 * @date 2024-01-01
 */
@Slf4j
@Service
public class ContractTemplateFieldCodeService {

    @Resource
    private ContractTemplateFieldMapper contractTemplateFieldMapper;

    /**
     * 获取指定模板的所有字段编码
     * 
     * @param templateId 模板ID
     * @return 字段编码集合
     */
    public Set<String> getTemplateFieldCodes(Integer templateId) {
        List<ContractTemplateFieldEntity> fields = contractTemplateFieldMapper.selectList(
                new LambdaQueryWrapper<ContractTemplateFieldEntity>()
                        .eq(ContractTemplateFieldEntity::getTemplateId, templateId)
        );
        
        return fields.stream()
                .map(ContractTemplateFieldEntity::getFieldCode)
                .collect(Collectors.toSet());
    }

    /**
     * 获取所有已使用的字段编码
     * 
     * @return 所有已使用的字段编码集合
     */
    public Set<String> getAllUsedFieldCodes() {
        List<ContractTemplateFieldEntity> allFields = contractTemplateFieldMapper.selectList(null);
        return allFields.stream()
                .map(ContractTemplateFieldEntity::getFieldCode)
                .filter(code -> code != null && !code.trim().isEmpty())
                .collect(Collectors.toSet());
    }

    /**
     * 为指定数量的字段生成编码
     * 
     * @param fieldCount 字段数量
     * @return 生成的字段编码列表
     */
    public List<String> generateFieldCodesForTemplate(int fieldCount) {
        Set<String> existingCodes = getAllUsedFieldCodes();
        return FieldCodeGenerator.generateFieldCodes(fieldCount, existingCodes);
    }

    /**
     * 生成下一个可用的字段编码
     * 
     * @return 下一个可用的字段编码
     */
    public String generateNextFieldCode() {
        Set<String> existingCodes = getAllUsedFieldCodes();
        return FieldCodeGenerator.generateNextFieldCode(existingCodes);
    }

    /**
     * 验证字段编码是否可用
     * 
     * @param fieldCode 待验证的字段编码
     * @param excludeTemplateId 排除的模板ID（用于更新场景）
     * @return 是否可用
     */
    public boolean isFieldCodeAvailable(String fieldCode, Integer excludeTemplateId) {
        if (!FieldCodeGenerator.isValidFieldCode(fieldCode)) {
            return false;
        }
        
        LambdaQueryWrapper<ContractTemplateFieldEntity> queryWrapper = 
                new LambdaQueryWrapper<ContractTemplateFieldEntity>()
                        .eq(ContractTemplateFieldEntity::getFieldCode, fieldCode);
        
        if (excludeTemplateId != null) {
            queryWrapper.ne(ContractTemplateFieldEntity::getTemplateId, excludeTemplateId);
        }
        
        return contractTemplateFieldMapper.selectCount(queryWrapper) == 0;
    }

    /**
     * 批量验证字段编码是否可用
     * 
     * @param fieldCodes 待验证的字段编码列表
     * @param excludeTemplateId 排除的模板ID
     * @return 验证结果，key为字段编码，value为是否可用
     */
    public java.util.Map<String, Boolean> validateFieldCodes(List<String> fieldCodes, Integer excludeTemplateId) {
        return fieldCodes.stream()
                .collect(Collectors.toMap(
                        code -> code,
                        code -> isFieldCodeAvailable(code, excludeTemplateId)
                ));
    }
} 